home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / share / gettext / intl / localealias.c < prev    next >
Encoding:
C/C++ Source or Header  |  2007-03-05  |  10.3 KB  |  438 lines
  1. /* Handle aliases for locale names.
  2.    Copyright (C) 1995-1999, 2000-2001, 2003, 2005 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify it
  5.    under the terms of the GNU Library General Public License as published
  6.    by the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.    Library General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU Library General Public
  15.    License along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17.    USA.  */
  18.  
  19. /* Tell glibc's <string.h> to provide a prototype for mempcpy().
  20.    This must come before <config.h> because <config.h> may include
  21.    <features.h>, and once <features.h> has been included, it's too late.  */
  22. #ifndef _GNU_SOURCE
  23. # define _GNU_SOURCE    1
  24. #endif
  25.  
  26. #ifdef HAVE_CONFIG_H
  27. # include <config.h>
  28. #endif
  29.  
  30. #include <ctype.h>
  31. #include <stdio.h>
  32. #if defined _LIBC || defined HAVE___FSETLOCKING
  33. # include <stdio_ext.h>
  34. #endif
  35. #include <sys/types.h>
  36.  
  37. #ifdef __GNUC__
  38. # undef alloca
  39. # define alloca __builtin_alloca
  40. # define HAVE_ALLOCA 1
  41. #else
  42. # ifdef _MSC_VER
  43. #  include <malloc.h>
  44. #  define alloca _alloca
  45. # else
  46. #  if defined HAVE_ALLOCA_H || defined _LIBC
  47. #   include <alloca.h>
  48. #  else
  49. #   ifdef _AIX
  50.  #pragma alloca
  51. #   else
  52. #    ifndef alloca
  53. char *alloca ();
  54. #    endif
  55. #   endif
  56. #  endif
  57. # endif
  58. #endif
  59.  
  60. #include <stdlib.h>
  61. #include <string.h>
  62.  
  63. #include "gettextP.h"
  64.  
  65. #if ENABLE_RELOCATABLE
  66. # include "relocatable.h"
  67. #else
  68. # define relocate(pathname) (pathname)
  69. #endif
  70.  
  71. /* @@ end of prolog @@ */
  72.  
  73. #ifdef _LIBC
  74. /* Rename the non ANSI C functions.  This is required by the standard
  75.    because some ANSI C functions will require linking with this object
  76.    file and the name space must not be polluted.  */
  77. # define strcasecmp __strcasecmp
  78.  
  79. # ifndef mempcpy
  80. #  define mempcpy __mempcpy
  81. # endif
  82. # define HAVE_MEMPCPY    1
  83. # define HAVE___FSETLOCKING    1
  84. #endif
  85.  
  86. /* Handle multi-threaded applications.  */
  87. #ifdef _LIBC
  88. # include <bits/libc-lock.h>
  89. #else
  90. # include "lock.h"
  91. #endif
  92.  
  93. #ifndef internal_function
  94. # define internal_function
  95. #endif
  96.  
  97. /* Some optimizations for glibc.  */
  98. #ifdef _LIBC
  99. # define FEOF(fp)        feof_unlocked (fp)
  100. # define FGETS(buf, n, fp)    fgets_unlocked (buf, n, fp)
  101. #else
  102. # define FEOF(fp)        feof (fp)
  103. # define FGETS(buf, n, fp)    fgets (buf, n, fp)
  104. #endif
  105.  
  106. /* For those losing systems which don't have `alloca' we have to add
  107.    some additional code emulating it.  */
  108. #ifdef HAVE_ALLOCA
  109. # define freea(p) /* nothing */
  110. #else
  111. # define alloca(n) malloc (n)
  112. # define freea(p) free (p)
  113. #endif
  114.  
  115. #if defined _LIBC_REENTRANT || HAVE_DECL_FGETS_UNLOCKED
  116. # undef fgets
  117. # define fgets(buf, len, s) fgets_unlocked (buf, len, s)
  118. #endif
  119. #if defined _LIBC_REENTRANT || HAVE_DECL_FEOF_UNLOCKED
  120. # undef feof
  121. # define feof(s) feof_unlocked (s)
  122. #endif
  123.  
  124.  
  125. __libc_lock_define_initialized (static, lock)
  126.  
  127.  
  128. struct alias_map
  129. {
  130.   const char *alias;
  131.   const char *value;
  132. };
  133.  
  134.  
  135. #ifndef _LIBC
  136. # define libc_freeres_ptr(decl) decl
  137. #endif
  138.  
  139. libc_freeres_ptr (static char *string_space);
  140. static size_t string_space_act;
  141. static size_t string_space_max;
  142. libc_freeres_ptr (static struct alias_map *map);
  143. static size_t nmap;
  144. static size_t maxmap;
  145.  
  146.  
  147. /* Prototypes for local functions.  */
  148. static size_t read_alias_file (const char *fname, int fname_len)
  149.      internal_function;
  150. static int extend_alias_table (void);
  151. static int alias_compare (const struct alias_map *map1,
  152.               const struct alias_map *map2);
  153.  
  154.  
  155. const char *
  156. _nl_expand_alias (const char *name)
  157. {
  158.   static const char *locale_alias_path;
  159.   struct alias_map *retval;
  160.   const char *result = NULL;
  161.   size_t added;
  162.  
  163.   __libc_lock_lock (lock);
  164.  
  165.   if (locale_alias_path == NULL)
  166.     locale_alias_path = LOCALE_ALIAS_PATH;
  167.  
  168.   do
  169.     {
  170.       struct alias_map item;
  171.  
  172.       item.alias = name;
  173.  
  174.       if (nmap > 0)
  175.     retval = (struct alias_map *) bsearch (&item, map, nmap,
  176.                            sizeof (struct alias_map),
  177.                            (int (*) (const void *,
  178.                              const void *)
  179.                         ) alias_compare);
  180.       else
  181.     retval = NULL;
  182.  
  183.       /* We really found an alias.  Return the value.  */
  184.       if (retval != NULL)
  185.     {
  186.       result = retval->value;
  187.       break;
  188.     }
  189.  
  190.       /* Perhaps we can find another alias file.  */
  191.       added = 0;
  192.       while (added == 0 && locale_alias_path[0] != '\0')
  193.     {
  194.       const char *start;
  195.  
  196.       while (locale_alias_path[0] == PATH_SEPARATOR)
  197.         ++locale_alias_path;
  198.       start = locale_alias_path;
  199.  
  200.       while (locale_alias_path[0] != '\0'
  201.          && locale_alias_path[0] != PATH_SEPARATOR)
  202.         ++locale_alias_path;
  203.  
  204.       if (start < locale_alias_path)
  205.         added = read_alias_file (start, locale_alias_path - start);
  206.     }
  207.     }
  208.   while (added != 0);
  209.  
  210.   __libc_lock_unlock (lock);
  211.  
  212.   return result;
  213. }
  214.  
  215.  
  216. static size_t
  217. internal_function
  218. read_alias_file (const char *fname, int fname_len)
  219. {
  220.   FILE *fp;
  221.   char *full_fname;
  222.   size_t added;
  223.   static const char aliasfile[] = "/locale.alias";
  224.  
  225.   full_fname = (char *) alloca (fname_len + sizeof aliasfile);
  226. #ifdef HAVE_MEMPCPY
  227.   mempcpy (mempcpy (full_fname, fname, fname_len),
  228.        aliasfile, sizeof aliasfile);
  229. #else
  230.   memcpy (full_fname, fname, fname_len);
  231.   memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
  232. #endif
  233.  
  234. #ifdef _LIBC
  235.   /* Note the file is opened with cancellation in the I/O functions
  236.      disabled.  */
  237.   fp = fopen (relocate (full_fname), "rc");
  238. #else
  239.   fp = fopen (relocate (full_fname), "r");
  240. #endif
  241.   freea (full_fname);
  242.   if (fp == NULL)
  243.     return 0;
  244.  
  245. #ifdef HAVE___FSETLOCKING
  246.   /* No threads present.  */
  247.   __fsetlocking (fp, FSETLOCKING_BYCALLER);
  248. #endif
  249.  
  250.   added = 0;
  251.   while (!FEOF (fp))
  252.     {
  253.       /* It is a reasonable approach to use a fix buffer here because
  254.      a) we are only interested in the first two fields
  255.      b) these fields must be usable as file names and so must not
  256.         be that long
  257.      We avoid a multi-kilobyte buffer here since this would use up
  258.      stack space which we might not have if the program ran out of
  259.      memory.  */
  260.       char buf[400];
  261.       char *alias;
  262.       char *value;
  263.       char *cp;
  264.       int complete_line;
  265.  
  266.       if (FGETS (buf, sizeof buf, fp) == NULL)
  267.     /* EOF reached.  */
  268.     break;
  269.  
  270.       /* Determine whether the line is complete.  */
  271.       complete_line = strchr (buf, '\n') != NULL;
  272.  
  273.       cp = buf;
  274.       /* Ignore leading white space.  */
  275.       while (isspace ((unsigned char) cp[0]))
  276.     ++cp;
  277.  
  278.       /* A leading '#' signals a comment line.  */
  279.       if (cp[0] != '\0' && cp[0] != '#')
  280.     {
  281.       alias = cp++;
  282.       while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
  283.         ++cp;
  284.       /* Terminate alias name.  */
  285.       if (cp[0] != '\0')
  286.         *cp++ = '\0';
  287.  
  288.       /* Now look for the beginning of the value.  */
  289.       while (isspace ((unsigned char) cp[0]))
  290.         ++cp;
  291.  
  292.       if (cp[0] != '\0')
  293.         {
  294.           value = cp++;
  295.           while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
  296.         ++cp;
  297.           /* Terminate value.  */
  298.           if (cp[0] == '\n')
  299.         {
  300.           /* This has to be done to make the following test
  301.              for the end of line possible.  We are looking for
  302.              the terminating '\n' which do not overwrite here.  */
  303.           *cp++ = '\0';
  304.           *cp = '\n';
  305.         }
  306.           else if (cp[0] != '\0')
  307.         *cp++ = '\0';
  308.  
  309. #ifdef IN_LIBGLOCALE
  310.           /* glibc's locale.alias contains entries for ja_JP and ko_KR
  311.          that make it impossible to use a Japanese or Korean UTF-8
  312.          locale under the name "ja_JP" or "ko_KR".  Ignore these
  313.          entries.  */
  314.           if (strchr (alias, '_') == NULL)
  315. #endif
  316.         {
  317.           size_t alias_len;
  318.           size_t value_len;
  319.  
  320.           if (nmap >= maxmap)
  321.             if (__builtin_expect (extend_alias_table (), 0))
  322.               goto out;
  323.  
  324.           alias_len = strlen (alias) + 1;
  325.           value_len = strlen (value) + 1;
  326.  
  327.           if (string_space_act + alias_len + value_len > string_space_max)
  328.             {
  329.               /* Increase size of memory pool.  */
  330.               size_t new_size = (string_space_max
  331.                      + (alias_len + value_len > 1024
  332.                         ? alias_len + value_len : 1024));
  333.               char *new_pool = (char *) realloc (string_space, new_size);
  334.               if (new_pool == NULL)
  335.             goto out;
  336.  
  337.               if (__builtin_expect (string_space != new_pool, 0))
  338.             {
  339.               size_t i;
  340.  
  341.               for (i = 0; i < nmap; i++)
  342.                 {
  343.                   map[i].alias += new_pool - string_space;
  344.                   map[i].value += new_pool - string_space;
  345.                 }
  346.             }
  347.  
  348.               string_space = new_pool;
  349.               string_space_max = new_size;
  350.             }
  351.  
  352.           map[nmap].alias = memcpy (&string_space[string_space_act],
  353.                         alias, alias_len);
  354.           string_space_act += alias_len;
  355.  
  356.           map[nmap].value = memcpy (&string_space[string_space_act],
  357.                         value, value_len);
  358.           string_space_act += value_len;
  359.  
  360.           ++nmap;
  361.           ++added;
  362.         }
  363.         }
  364.     }
  365.  
  366.       /* Possibly not the whole line fits into the buffer.  Ignore
  367.      the rest of the line.  */
  368.       if (! complete_line)
  369.     do
  370.       if (FGETS (buf, sizeof buf, fp) == NULL)
  371.         /* Make sure the inner loop will be left.  The outer loop
  372.            will exit at the `feof' test.  */
  373.         break;
  374.     while (strchr (buf, '\n') == NULL);
  375.     }
  376.  
  377.  out:
  378.   /* Should we test for ferror()?  I think we have to silently ignore
  379.      errors.  --drepper  */
  380.   fclose (fp);
  381.  
  382.   if (added > 0)
  383.     qsort (map, nmap, sizeof (struct alias_map),
  384.        (int (*) (const void *, const void *)) alias_compare);
  385.  
  386.   return added;
  387. }
  388.  
  389.  
  390. static int
  391. extend_alias_table ()
  392. {
  393.   size_t new_size;
  394.   struct alias_map *new_map;
  395.  
  396.   new_size = maxmap == 0 ? 100 : 2 * maxmap;
  397.   new_map = (struct alias_map *) realloc (map, (new_size
  398.                         * sizeof (struct alias_map)));
  399.   if (new_map == NULL)
  400.     /* Simply don't extend: we don't have any more core.  */
  401.     return -1;
  402.  
  403.   map = new_map;
  404.   maxmap = new_size;
  405.   return 0;
  406. }
  407.  
  408.  
  409. static int
  410. alias_compare (const struct alias_map *map1, const struct alias_map *map2)
  411. {
  412. #if defined _LIBC || defined HAVE_STRCASECMP
  413.   return strcasecmp (map1->alias, map2->alias);
  414. #else
  415.   const unsigned char *p1 = (const unsigned char *) map1->alias;
  416.   const unsigned char *p2 = (const unsigned char *) map2->alias;
  417.   unsigned char c1, c2;
  418.  
  419.   if (p1 == p2)
  420.     return 0;
  421.  
  422.   do
  423.     {
  424.       /* I know this seems to be odd but the tolower() function in
  425.      some systems libc cannot handle nonalpha characters.  */
  426.       c1 = isupper (*p1) ? tolower (*p1) : *p1;
  427.       c2 = isupper (*p2) ? tolower (*p2) : *p2;
  428.       if (c1 == '\0')
  429.     break;
  430.       ++p1;
  431.       ++p2;
  432.     }
  433.   while (c1 == c2);
  434.  
  435.   return c1 - c2;
  436. #endif
  437. }
  438.